import {Http} from "./http";

class Paging {

    /**
     * 封装
     * 不关心细节
     * 对象保存为什么状态
     *  肯定要实例化来保存
     */
        // 分页初始参数
    start
    count
    // 请求相关参数 地址 请求方式
    req
    // 请求地址
    url
    // 是否拥有更多数据
    moreData = true
    // 每次分页数据
    accumulator = []

    /**
     * 请求服务器需要的参数
     * @param req  请求参数 method params
     * @param count
     * @param start
     */
    constructor(req, count = 10, start = 0) {
        this.start = start
        this.count = count
        this.req = req
        this.url = req.url
    }

    /**
     * 返回当前请求参数
     * @returns {*}
     * @private
     */
    _getCurrentReq() {
        let url = this.url
        const params = `start=${this.start}&count=${this.count}`
        // url = v1/spu/latest + "?" + params
        // url = v1/spu/latest?other=abc+'&'+params
        if (url.includes("?")) {
            // 连接中存在问号 则拼接 &
            url += '&' + params
        } else {
            url += '?' + params
        }
        this.req.url = url
        return this.req
    }

    /**
     * 获取更多数据
     *
     */
    async getMoreData() {
        // 没有更多数据 不请求
        if (!this.moreData) {
            return
        }
        if (!this._getLocker()) {
            return
        }
        const data = await this._actualGetData()
        this._releaseLocker()
        return data
    }

    /**
     * 请求数据
     * @private
     */
    async _actualGetData() {
        const req = this._getCurrentReq()
        let paging = await Http.request(req)
        if (!paging) {
            return null
        }
        if (paging.total === 0) {
            return {
                empty: true,
                items: [],
                moreData: false,
                accumulator: []
            }
        }
        // 判断是否还有更多数据
        this.moreData = Paging._moreData(paging.total_page, paging.page)
        // 如果还有数据，那么增加请求累加数
        if (this.moreData) {
            this.start += this.count
        }
        // 积累之前分页数据
        this._accumulate(paging.items)
        /**
         * 统一返回数据结构
         * js中负责的话可以考虑返回 class
         * 根据细节来进行设计
         */
        return {
            // 标识是否为空
            empty: false,
            // 存放分页请求的数据
            items: paging.items,
            // 是否还有下一页数据
            moreData: this.moreData,
            // 累加器 累加之前请求的数据
            accumulator: this.accumulator
        }
    }

    /**
     * 累加每次请求分页获取的数据
     * const 合并数组
     * @param items 每次请求获取的分页数据
     * @private
     */
    _accumulate(items) {
        this.accumulator = this.accumulator.concat(items)
    }

    /**
     * 是否还有更多的数据
     * @param totalPage 分页返回 数量
     * @param pageNum 页码
     * @returns {boolean} 是否还有数据
     * @private
     */
    static _moreData(totalPage, pageNum) {
        return pageNum < totalPage - 1
    }

    /**
     * 上锁
     * @private
     */
    _getLocker() {
        return true
    }

    /**
     * 释放锁
     * @private
     */
    _releaseLocker() {
        return false
    }
}

export {
    Paging
}